import { T_task } from '@/obj/class/base/task/index';
import * as echarts from 'echarts';
import { getValidChartConfig, ifs, N_cBaseChart, Tsrv } from './config';

class T_cmd {
  // 主组件箱
  private compBox: ifs.I_compBox;

  // 主组件ID
  private compID: string;

  private task: T_task = new T_task(5000);

  // 主组件实例
  private self: N_cBaseChart.cBaseChart;

  // 图表配置
  private chartConfig: N_cBaseChart.ChartConfig;

  // ECharts实例
  private chartInstance: any = null;

  // 数据队列
  private dataQueue: any[] = [];

  // 定时器引用
  private refreshTimer: any = null;

  // 当前数据
  private currentData: any = null;

  // 主组件created里初始化
  public init(self: N_cBaseChart.cBaseChart, compBoxInfo: ifs.I_compBoxInfo) {
    this.self = self;
    this.compBox = compBoxInfo.TcompBox;
    this.compID = compBoxInfo.compID;
    
    // 初始化配置
    this.chartConfig = getValidChartConfig(self.config);
  }

  /**
   * 初始化图表
   */
  public initChart(): void {
    if (!this.self) {
      console.error('组件未挂载，无法初始化图表');
      return;
    }

    try {
      // 销毁现有实例
      this.dispose();

      // 创建新的ECharts实例
      // const chartDom = this.self.$el.querySelector('.chart-container');
      const chartDom = this.self.$refs.chartContainer as HTMLDivElement;
      if (!chartDom) {
        console.error('找不到图表容器');
        return;
      }

      this.chartInstance = echarts.init(chartDom, this.chartConfig.chart.theme);
      
      // 设置初始选项
      this.updateChartOptions();
      
      // 启动数据刷新任务
      this.startDataRefreshTask();

      // 监听窗口大小变化
      window.addEventListener('resize', this.handleResize.bind(this));

    } catch (error) {
      console.error('初始化图表失败:', error);
    }
  }

  /**
   * 更新图表数据
   */
  public updateData(newData: any): void {
    if (!newData) return;

    this.currentData = newData;
    
    // 处理数据（降重等逻辑由用户实现）
    const processedData = this.processData(newData);
    
    // 更新数据队列
    this.updateDataQueue(processedData);
    
    // 更新图表
    this.updateChartOptions();
  }

  /**
   * 刷新图表数据
   */
  public refresh(): void {
    if (this.chartConfig.data.source.type === 'scada-api') {
      this.fetchDataFromAPI();
    } else if (this.chartConfig.data.source.type === 'database') {
      this.fetchDataFromDatabase();
    }
    // 静态数据不需要刷新
  }

  /**
   * 调整图表尺寸
   */
  public resize(): void {
    if (this.chartInstance) {
      this.chartInstance.resize();
    }
  }

  /**
   * 销毁图表实例
   */
  public dispose(): void {
    // 清除定时器
    this.stopDataRefreshTask();
    
    // 移除事件监听
    window.removeEventListener('resize', this.handleResize.bind(this));
    
    // 销毁ECharts实例
    if (this.chartInstance) {
      this.chartInstance.dispose();
      this.chartInstance = null;
    }
    
    // 清空数据队列
    this.dataQueue = [];
  }

  /**
   * 获取ECharts实例
   */
  public getInstance(): any {
    return this.chartInstance;
  }

  /**
   * 处理数据（降重等逻辑由用户实现）
   */
  private processData(data: any): any {
    // 这里预留数据处理的接口
    // 用户可以根据自己的降重算法在这里实现
    return data;
  }

  /**
   * 更新数据队列
   */
  private updateDataQueue(newData: any): void {
    // 添加到队列
    this.dataQueue.push(newData);
    
    // 保持队列长度不超过配置的最大点数
    const maxPoints = this.chartConfig.data.source.maxPoints;
    if (this.dataQueue.length > maxPoints) {
      this.dataQueue = this.dataQueue.slice(-maxPoints);
    }
  }

  /**
   * 更新图表选项
   */
  private updateChartOptions(): void {
    if (!this.chartInstance) return;

    const option = this.generateEChartsOption();
    this.chartInstance.setOption(option, true);
  }

  /**
   * 生成ECharts配置选项
   */
  private generateEChartsOption(): any {
    const { chart, xAxis, yAxis, series, tooltip, legend, grid, toolbox, dataZoom, animation, backgroundColor, textStyle } = this.chartConfig;

    return {
      title: chart.title,
      tooltip: tooltip || {
        trigger: 'axis',
        axisPointer: {
          type: 'cross'
        }
      },
      legend: legend || {
        data: series.map(s => s.name)
      },
      grid: grid || {
        left: '3%',
        right: '4%',
        bottom: '3%',
        containLabel: true
      },
      toolbox: toolbox,
      dataZoom: dataZoom,
      xAxis: {
        ...xAxis,
        data: this.dataQueue.map(item => item[this.chartConfig.data.mapping.xAxis])
      },
      yAxis: yAxis,
      series: series.map((s, index) => {
        const seriesData = this.dataQueue.map(item => {
          const field = this.chartConfig.data.mapping.series[index]?.field;
          return field ? item[field] : null;
        });

        return {
          ...s,
          data: seriesData
        };
      }),
      animation: animation,
      backgroundColor: backgroundColor,
      textStyle: textStyle
    };
  }

  /**
   * 从API获取数据
   */
  private async fetchDataFromAPI(): Promise<void> {
    const { endpoint, auth } = this.chartConfig.data.source;
    
    if (!endpoint) {
      console.error('API端点未配置');
      return;
    }

    try {
      

      // const data = await response.json();
      // this.updateData(data);

    } catch (error) {
      console.error('获取API数据失败:', error);
      // 可以在这里实现错误处理逻辑，比如重试机制
    }
  }

  /**
   * 从数据库获取数据（预留接口）
   */
  private async fetchDataFromDatabase(): Promise<void> {
    // 这里预留数据库查询接口
    // 用户可以根据自己的数据库实现这里
    console.warn('数据库数据获取功能需要用户自行实现');
  }

  /**
   * 启动数据刷新任务
   */
  private startDataRefreshTask(): void {
    const interval = this.chartConfig.data.source.refreshInterval;
    
    if (interval > 0) {
      this.refreshTimer = setInterval(() => {
        this.refresh();
      }, interval);
    }
  }

  /**
   * 停止数据刷新任务
   */
  private stopDataRefreshTask(): void {
    if (this.refreshTimer) {
      clearInterval(this.refreshTimer);
      this.refreshTimer = null;
    }
  }

    // 新增降采样方法
  public downsampleData(data: ifs.I_codeData['d'], interval: number) {
    if (!data || data.length === 0) return [];

    // 按时间排序
    const sortedData = data.sort(
      (a, b) => new Date(a.t).getTime() - new Date(b.t).getTime()
    );

    // 按指定间隔分组
    const grouped = Tsrv.utils.groupBy(sortedData, item => {
      // 将时间戳转换成本地时间
      const date = new Date(item.t).toLocaleString();
      const timestamp = new Date(date).getTime();
      return Math.floor(timestamp / interval) * interval;
    });
    // 处理每组数据
    return Object.values(grouped).map(group => {
      const values = group.map(item => item.v);
      // 保留两位小数
      const avg = Math.round(Tsrv.utils.mean(values) * 100) / 100;

      return {
        t: group[0].t,
        v: avg
      };
    });
  }

  /**
   * 处理窗口大小变化
   */
  private handleResize(): void {
    this.resize();
  }

  public getTcmd(): T_cmd {
    return this;
  }
}

interface I_cmd extends T_cmd {}
export { I_cmd, T_cmd };
